// This file is part of Noggit3, licensed under GNU General Public License (version 3).

#include <noggit/ConfigFile.h>

#include <string>

using std::string;

ConfigFile::ConfigFile(string filename, string delimiter,
  string comment, string sentry)
  : myDelimiter(delimiter), myComment(comment), mySentry(sentry)
{
  // Construct a ConfigFile, getting keys and values from given file

  std::ifstream in(filename.c_str());

  if (!in) throw file_not_found(filename);

  in >> (*this);
}


ConfigFile::ConfigFile()
  : myDelimiter(string(1, '=')), myComment(string(1, '#'))
{
  // Construct a ConfigFile without a file; empty
}


void ConfigFile::remove(const string& key)
{
  // Remove key and its value
  myContents.erase(myContents.find(key));
  return;
}


bool ConfigFile::keyExists(const string& key) const
{
  // Indicate whether key is found
  mapci p = myContents.find(key);
  return (p != myContents.end());
}


/* static */
void ConfigFile::trim(string* s)
{
  // Remove leading and trailing whitespace
  static const char whitespace[] = " \n\t\v\r\f";
  s->erase(0, s->find_first_not_of(whitespace));
  s->erase(s->find_last_not_of(whitespace) + 1U);
}


std::ostream& operator<<(std::ostream& os, const ConfigFile& cf)
{
  // Save a ConfigFile to os
  for (ConfigFile::mapci p = cf.myContents.begin();
    p != cf.myContents.end();
    ++p)
  {
    os << p->first << " " << cf.myDelimiter << " ";
    os << p->second << std::endl;
  }
  return os;
}


std::istream& operator>>(std::istream& is, ConfigFile& cf)
{
  // Load a ConfigFile from is
  // Read in keys and values, keeping internal whitespace
  typedef string::size_type pos;
  const string& delim = cf.myDelimiter;  // separator
  const string& comm = cf.myComment;    // comment
  const string& sentry = cf.mySentry;     // end of file sentry
  const pos skip = delim.length();        // length of separator

  string nextline = "";  // might need to read ahead to see where value ends

  while (is || nextline.length() > 0)
  {
    // Read an entire line at a time
    string line;
    if (nextline.length() > 0)
    {
      line = nextline;  // we read ahead; use it now
      nextline = "";
    }
    else
    {
      std::getline(is, line);
    }

    // Ignore comments
    line = line.substr(0, line.find(comm));

    // Check for end of file sentry
    if (sentry != "" && line.find(sentry) != string::npos) return is;

    // Parse the line if it contains a delimiter
    pos delimPos = line.find(delim);
    if (delimPos < string::npos)
    {
      // Extract the key
      string key = line.substr(0, delimPos);
      line.replace(0, delimPos + skip, "");

      // See if value continues on the next line
      // Stop at blank line, next line with a key, end of stream,
      // or end of file sentry
      bool terminate = false;
      while (!terminate && is)
      {
        std::getline(is, nextline);
        terminate = true;

        string nlcopy = nextline;
        ConfigFile::trim(&nlcopy);
        if (nlcopy == "") continue;

        nextline = nextline.substr(0, nextline.find(comm));
        if (nextline.find(delim) != string::npos)
          continue;
        if (sentry != "" && nextline.find(sentry) != string::npos)
          continue;

        nlcopy = nextline;
        ConfigFile::trim(&nlcopy);
        if (nlcopy != "") line += "\n";
        line += nextline;
        terminate = false;
      }

      // Store key and value
      ConfigFile::trim(&key);
      ConfigFile::trim(&line);
      cf.myContents[key] = line;  // overwrites if key is repeated
    }
  }

  return is;
}
